Capítulo 5: Organizando o Código – Funções, Módulos e Classes

Imagine que você precisa calcular a densidade populacional de várias cidades. No começo, você poderia escrever o cálculo `populacao / area` repetidamente. Mas e se a fórmula mudar? Você teria que corrigir em todos os lugares. Isso é ineficiente e propenso a erros.

Neste capítulo, vamos aprender a organizar nosso código em "pacotes" lógicos e reutilizáveis. Essas ferramentas são os pilares da programação moderna e o segredo por trás de bibliotecas como Pandas e GeoPandas. Vamos transformar a bagunça em organização, usando:

• Funções: "Receitas de bolo" que executam uma tarefa específica.
• Módulos: "Caixas de ferramentas" para guardar suas funções.
• Classes: "Plantas baixas" para criar objetos do mundo real, como um 'Município' ou um 'Rio'.

Uma função é um bloco de código nomeado que realiza uma tarefa específica. Você define a "receita" uma vez e pode usá-la quantas vezes quiser, apenas chamando seu nome.

Definindo uma Função

Usamos a palavra-chave def, seguida pelo nome da função e parênteses. O código que pertence à função deve ser indentado.

# Definindo nossa primeira função
def saudacao():
    print("Olá! Bem-vindo ao nosso script de geoprocessamento.")

# Chamando (executando) a função
saudacao()
saudacao()

Parâmetros (Entradas): Tornando a Função Flexível

Para que uma função seja útil, ela precisa receber dados para trabalhar. Esses dados são chamados de parâmetros (ou argumentos).

# Uma função que recebe um nome como parâmetro
def saudacao_personalizada(nome_da_cidade):
    print(f"Analisando dados para a cidade de {nome_da_cidade}...")

# Chamando a função com diferentes argumentos
saudacao_personalizada("Florianópolis")
saudacao_personalizada("Chapecó")

Retorno (Saídas): Obtendo um Resultado

Muitas vezes, queremos que a função nos devolva um valor. Para isso, usamos a palavra-chave return.

Exemplo Prático de Geo: Função de Densidade

Vamos criar nossa primeira ferramenta geoespacial: uma função que calcula a densidade populacional.

def calcular_densidade(populacao, area_km2):
    """Calcula a densidade populacional (hab/km²)."""
    if area_km2 <= 0:
        return 0  # Evita divisão por zero
    
    densidade = populacao / area_km2
    return densidade

# Usando nossa nova função
pop_florianopolis = 537213
area_florianopolis = 675.4

densidade_fln = calcular_densidade(pop_florianopolis, area_florianopolis)

print(f"A densidade de Florianópolis é de {densidade_fln:.2f} hab/km².")

# Reutilizando para outra cidade
pop_joinville = 616323
area_joinville = 1126.1

densidade_jve = calcular_densidade(pop_joinville, area_joinville)
print(f"A densidade de Joinville é de {densidade_jve:.2f} hab/km².")

À medida que criamos mais funções, nosso script principal pode ficar longo e confuso. A solução é organizar funções relacionadas em arquivos separados, chamados módulos. Pense em um módulo como uma "caixa de ferramentas" para um tipo específico de tarefa.

Como Criar um Módulo

É surpreendentemente simples: um módulo é apenas um arquivo Python com a extensão .py.

1. Crie um novo arquivo chamado geo_utils.py.
2. Mova ou copie sua função calcular_densidade para dentro dele.

O arquivo geo_utils.py agora é um módulo!

Importando seu Módulo

Agora, em seu script principal (por exemplo, analise_principal.py), você pode "importar" sua caixa de ferramentas e usar o que está dentro dela.

# Dentro do arquivo: analise_principal.py

# Importa o módulo que criamos (o arquivo geo_utils.py)
import geo_utils

# Agora podemos usar a função que está dentro do módulo
densidade_chapeco = geo_utils.calcular_densidade(254789, 214.3)

print(f"A densidade de Chapecó é {densidade_chapeco:.2f} hab/km².")

Funções são ótimas para representar ações, mas e as "coisas"? No geoprocessamento, lidamos com municípios, rios, pontos de interesse. Essas "coisas" têm tanto dados (características) quanto comportamentos (ações). A POO nos ajuda a modelar isso.

Classes e Objetos: A Planta e a Casa

• Classe: É a "planta baixa" ou o "formulário em branco". Define quais características uma coisa deve ter. Ex: Uma classe `Municipio` define que todo município terá um nome, um código IBGE e uma área.
• Objeto: É a "casa construída" ou o "formulário preenchido". É uma instância específica da classe. Ex: O objeto `florianopolis` é uma instância da classe `Municipio` com dados reais.

Exemplo Prático de Geo: Classe `PontoDeInteresse`

Vamos criar um modelo para representar pontos de interesse (POIs) em um mapa.

class PontoDeInteresse:
    # O "construtor": método especial que cria o objeto e define seus atributos
    def __init__(self, nome, latitude, longitude, tipo):
        # Atributos: as características do objeto
        self.nome = nome
        self.lat = latitude
        self.lon = longitude
        self.tipo = tipo
        self.visitado = False  # Um atributo com valor padrão

    # Método: uma "ação" que o objeto pode fazer
    def exibir_informacoes(self):
        status = "Visitado" if self.visitado else "Não Visitado"
        print("--- Ponto de Interesse ---")
        print(f"Nome: {self.nome} ({self.tipo})")
        print(f"Coordenadas: ({self.lat}, {self.lon})")
        print(f"Status: {status}")

    # Outro método
    def marcar_como_visitado(self):
        self.visitado = True
        print(f"O ponto '{self.nome}' foi marcado como visitado.")

# --- Usando nossa classe para criar objetos ---

# Criando o primeiro objeto (instância da classe)
pico_da_bandeira = PontoDeInteresse("Pico da Bandeira", -20.43, -41.82, "Pico de Montanha")

# Criando outro objeto
ifsc_centro = PontoDeInteresse("IFSC Câmpus Florianópolis", -27.59, -48.54, "Instituição de Ensino")

# Usando os métodos dos objetos
pico_da_bandeira.exibir_informacoes()
print("-" * 20)
ifsc_centro.exibir_informacoes()

# Modificando um objeto
ifsc_centro.marcar_como_visitado()
ifsc_centro.exibir_informacoes()

Parabéns! Você acabou de aprender os três conceitos que separam scripts simples de softwares robustos:

• Funções para empacotar lógica e reutilizá-la.
• Módulos para organizar suas funções e criar suas próprias "bibliotecas".
• Classes e Objetos para modelar entidades do mundo real com características e comportamentos.

Com essa base, você está pronto para entender não apenas *como usar* bibliotecas como Pandas e GeoPandas, mas também *como elas são construídas*. No próximo capítulo, vamos mergulhar de cabeça nessas ferramentas, e você verá que um `DataFrame` do Pandas nada mais é do que um objeto, criado a partir de uma classe, com muitos métodos úteis!